package com.zhihuishu.micro.course.service.impl;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.annotation.Resource;

import org.springframework.stereotype.Service;
import org.springframework.util.Assert;
import org.springframework.util.CollectionUtils;

import com.zhihuishu.micro.course.dao.LessonTestQuestionMapper;
import com.zhihuishu.micro.course.dto.LessonDto;
import com.zhihuishu.micro.course.helper.RedisKeyHelper;
import com.zhihuishu.micro.course.model.LessonTestQuestion;
import com.zhihuishu.micro.course.model.LessonVideo;
import com.zhihuishu.micro.course.model.LessonVideoCount;
import com.zhihuishu.micro.course.service.LessonService;
import com.zhihuishu.micro.course.service.LessonTestQuestionService;
import com.zhihuishu.micro.course.service.LessonVideoTreenityDBService;
import com.zhihuishu.toolkit.helper.BeanHelper;
import com.zhihuishu.toolkit.jedis.JedisHelper.Handler;

import redis.clients.jedis.Jedis;
@Service("lessonTestQuestionService")
public class LessonTestQuestionServiceImpl extends BaseService implements LessonTestQuestionService{
	
	@Resource
	private LessonTestQuestionMapper lessonTestQuestionMapper;
	
	@Resource
	private LessonService lessonService;
	
	@Resource
	private LessonVideoTreenityDBService lessonVideoAllServiceDB;
	
	
	// 缓存有效期
	private final int DEFAULT_EXPIRE = 7200;
	private String LessonTestQuestionIdsKeys="lessonTestQuestionIds";//用于存放keys的名称
	
	private final Integer Lesson_haveChildren_0=0;//节下面没有小节
	private final Integer Lesson_haveChildren_1=1;//节下面有一个小节
	private final Integer Lesson_haveChildren_2=2;//节下面有两个小节
	
	
	/**
	 * 数据库操作
	 * @author JinXing 
	 * @date 2017年3月8日 20:37:30
	 * 
	 * 根据小节id、节id 查找弹题List
	 * @param lessonId 	节id
	 * @param smallLessonId 小节id
	 * @return List<LessonTestQuestion>
	 * */
	private List<LessonTestQuestion> searchLessonTestQuestionInfoByLessonTestQuestion(LessonTestQuestion lessonTestQuestiontemp){
		List<LessonTestQuestion> lessonTestQuestionList=new ArrayList<LessonTestQuestion>();
		lessonTestQuestionList=lessonTestQuestionMapper.searchLessonTestQuestionInfoByLessonTestQuestion(lessonTestQuestiontemp);
		
		return lessonTestQuestionList;
	}
	

	/** 
	 * 数据库操作
	 * 
	* @Title: searchLessonTestQuestionInfoLength 
	* @Description: 获取结果集的长度
	* @param @param lessonTestQuestion
	* @param @return    设定文件 
	* @return Integer    返回类型 
	* @throws 
	*/
	private Integer searchLessonTestQuestionInfoLength(LessonTestQuestion lessonTestQuestion){
		
		return lessonTestQuestionMapper.searchLessonTestQuestionInfoLength(lessonTestQuestion);
		
	}
	
	/** 
	 * 数据库操作
	 * 
	* @Title: searchLessonTestQuestionInfoLengthByLessonId 
	* @Description: 根据节id查询 数据为null的视频打点信息
	* @param @param lessonId
	* @param @return    设定文件 
	* @return Integer    返回类型 
	* @throws 
	*/
	private Integer searchLessonTestQuestionInfoLengthByLessonId(LessonTestQuestion lessonTestQuestion){
		
		return lessonTestQuestionMapper.searchLessonTestQuestionInfoLengthByLessonId(lessonTestQuestion);
	}
	
	/**
	 * 数据库操作
	 * @author JinXing 
	 * @date 2017年3月8日 20:37:30
	 * 
	 * 根据id 查找弹题Dto
	 * @param lessonTestQuestionId 弹题id	
	 * @return LessonTestQuestion
	 * */
	private LessonTestQuestion searchLessonTestQuestionByid(Integer lessonTestQuestionId){
		LessonTestQuestion lessonTestQuestion=new LessonTestQuestion();
		
		//根据id查询LessonTestQuestion对象
		lessonTestQuestion=lessonTestQuestionMapper.searchLessonTestQuestionByid(lessonTestQuestionId);

		return lessonTestQuestion;
	}
	
	/**
	 * 加载数据 (用于接口数据支持)
	 * @author JinXing 
	 * @date 2017年3月8日 20:37:30
	 * 
	 * 根据小节id、节id 获取弹题List
	 * @param lessonId 节Id
	 * @param smallLessonId 小节id	
	 * @return List<LessonTestQuestion>
	 * */
	public List<LessonTestQuestion> getLessonTestQuestionListInfo(LessonTestQuestion lessonTestQuestiontemp){
		//根据小节id跟节id组装成LessonTestQuestion对象
		Integer lessonId=lessonTestQuestiontemp.getLessonId();
		Integer smallLessonId=lessonTestQuestiontemp.getSmallLessonId();
		
		Assert.notNull(smallLessonId,"smallLessonId must be a isn't empty");
		Assert.notNull(lessonId,"lessonId must be a isn't empty");
		
		//如果节下面存在两个小节，弹题与小节相关联 。存在一个小节与节相关联。（haveChildren =0:不存在小节  HaveChildren >0 表示小节总数）
		//将SmallLessonId设为null,就是用于区分所获取的缓存key
		Integer haveChildren=this.getLessonHaveChildrenCount(smallLessonId);
		if(haveChildren!=null && haveChildren<=1){
			smallLessonId=null;
		}
		
		//检查数据库中的数量与缓存的数量是否一致
		if(this.dbCompareRedisSource(lessonId, smallLessonId)){
			
			//从缓存获取数据
			List<LessonTestQuestion> lessonTestQuestion=this.getLessonTestListByRedis(lessonId, smallLessonId);
			//this.getLessonTestQuestionRedisDataList(lessonTestQuestiontemp.getSmallLessonId());
			
			//缓存中没有数据，走数据库放入缓存中
			if(CollectionUtils.isEmpty(lessonTestQuestion)){
				lessonTestQuestion=this.setLessonTestListByRedis(lessonId,smallLessonId);
			}
			return lessonTestQuestion;
		}
		
		return null;
	}
	
	/**
	 * 加载数据 (用于接口数据支持)
	 * @author JinXing 
	 * @date 2017年3月8日 20:37:30
	 * 
	 * 根据id 获取弹题Dto
	 * @param lessonTestQuestionId 
	 * @return LessonTestQuestion
	 * */
	public LessonTestQuestion getLessonTestQuestionInfo(Integer lessonTestQuestionId){
		Assert.notNull(lessonTestQuestionId,"lessonTestQuestionId must not be null");
		
		//从缓存获取数据
		LessonTestQuestion lessonTestQuestion=this.getLessonTestQuestionData(lessonTestQuestionId);
		
		//缓存中没有数据，走数据库放入缓存中
		if(lessonTestQuestion==null){
			lessonTestQuestion=this.setLessonTestQuestionData(lessonTestQuestionId);
		}
		return lessonTestQuestion;
	}
	
	/**
	 * 缓存操作
	 * @author JinXing 
	 * @date 2017年3月8日 20:37:30
	 * 
	 * 先走数据库查询list,将弹题key（每一个key对应缓存中的一条数据）存入缓存,将弹题keys存入缓存
	 * @param lessonId 节Id
	 * @param smallLessonId 小节id	
	 * @return List<LessonTestQuestion>
	 * */
	public List<LessonTestQuestion> setLessonTestQuestionRedisDataList(final Integer lessonId,final Integer smallLessonId){
		//走数据库加载数据
		LessonTestQuestion lessonTestQuestion=new LessonTestQuestion(lessonId,smallLessonId);
		List<LessonTestQuestion> lessonTestQuestionList=this.searchLessonTestQuestionInfoByLessonTestQuestion(lessonTestQuestion);
		if(lessonTestQuestionList==null){
			return lessonTestQuestionList;
		}
		//lessonTestQuestionids集合
		String keys="";
		for (final LessonTestQuestion lessonTestQuestiontemp : lessonTestQuestionList) {
			
			//将bean转换成map,自动过滤空值
			final Map<String,String> map=BeanHelper.describe(lessonTestQuestiontemp);
			//key值的格式为 cc:lessontestquestion:52421
			final String key=RedisKeyHelper.getlessonTestQuestionKey(lessonTestQuestiontemp.getLessonTestQuestionId());
			
			//将lessonTestQuestion对象存入缓存
			jedisExecutor.execute( new Handler() {
				@Override
				public void handle(Jedis jedis) {
					jedis.hmset(key, map);
					jedis.expire(RedisKeyHelper.getlessonTestQuestionKey(lessonTestQuestiontemp.getLessonTestQuestionId()), DEFAULT_EXPIRE);
				}
			});
			
			keys += key+",";	
		}
		
		//如果keys ，结尾,需要去掉逗号
		if(keys!=null && !"".equals(keys) && keys.endsWith(",")){
			keys=keys.substring(0,keys.length()-1);
		}
		//将小节所有lessonTestQuestion对象对应的keys存入缓存
		this.setLessonTestQuestionRedisIds(keys, smallLessonId);
		return lessonTestQuestionList;
	}
	
	
	/** 
	 * 为满足学堂视频弹题的展示，海外的弹题的key与cc的key存储方式。暂时调整一致 
	 * 
	* @Title: setLessonTestListByRedis 
	* @Description: 根据小节id、节id获取视频打点信息（数据库操作），根据cc打点的存储结构将获取的信息放入两个缓存中
	* @param @param lessonId
	* @param @param smallLessonId
	* @param @return    设定文件 
	* @return List<LessonTestQuestion>    返回类型 
	* @throws 
	*/
	public List<LessonTestQuestion> setLessonTestListByRedis(final Integer lessonId, final Integer smallLessonId){
		//走数据库加载数据
		try {
			final List<LessonTestQuestion> lessonTestQuestionList=this.searchLessonTestQuestionInfoByLessonTestQuestion(new LessonTestQuestion(lessonId,smallLessonId));
			
			if(!CollectionUtils.isEmpty(lessonTestQuestionList)){		
				
				jedisExecutor.execute( new Handler() {
					@Override
					public void handle(Jedis jedis) {
						
						String timers="";	
						Map<String,String> questionsMap=new HashMap<String, String>();//试题ids
						for (LessonTestQuestion lessonTestQuestion : lessonTestQuestionList) {
							if(lessonTestQuestion !=null){
								String timer=lessonTestQuestion.getTimer();
								if(timer !=null &&  !"".equals(timer)){
									//过滤到重复的时间点
									if(timers.indexOf(timer)==-1){
										timers+=timer+",";
									}
								
									//一个时间点可能对应多个试题id,避免一个时间点会存在重复的试题id
									String questionidsKey=RedisKeyHelper.getQuestionIds(lessonId, smallLessonId, timer);								
									String questionId=lessonTestQuestion.getTestQuestionId().toString();
									Integer id=lessonTestQuestion.getLessonTestQuestionId();
									if(questionId !=null &&  !"".equals(questionId)){
										
										String questionValue=questionsMap.get(questionidsKey);
										if(questionValue !=null &&  !"".equals(questionValue) && questionValue.trim().length() >0){
											questionValue=questionValue+","+questionId;
											questionsMap.put(questionidsKey, questionValue);
										}else{
											questionsMap.put(questionidsKey, questionId);
										}
																			
										//设置视频打点的主键id缓存（由于前段的业务用到了主键id.临时方案，缓存之后会有变更）
										 String idkey=RedisKeyHelper.getLessonTestionIds(lessonId, smallLessonId, timer, questionId);
										 jedis.set(idkey, id.toString());
										 jedis.expire(idkey, DEFAULT_EXPIRE);//设置key的失效时间
									}
									
								}
							}
							
							
						}
						
						//去除最后一个逗号
						if(timers !=null &&  !"".equals(timers) ){
							if(timers.endsWith(","))
							timers=timers.substring(0,timers.length()-1);
							
							//根据小节id、节id 设置时间点缓存
							String timersKey=RedisKeyHelper.getLessonTestQuestionTimerKey(lessonId, smallLessonId);
							jedis.set(timersKey, timers);
							jedis.expire(timersKey, DEFAULT_EXPIRE);//设置key的失效时间
						}
											
						//根据小节id、节id、时间点设置试题ids缓存
						if(questionsMap !=null && questionsMap.size()>0){
							for (Map.Entry<String, String> map : questionsMap.entrySet()) {
								jedis.set(map.getKey(), map.getValue());
								jedis.expire(map.getKey(), DEFAULT_EXPIRE);//设置key的失效时间
							}
						}
						
					}
				});
				
				
			}
			return lessonTestQuestionList;
		} catch (Exception e) {
			log.error(e.toString());
		}
		
		return null;		
	}
	
	
	/**
	 * 缓存操作
	 * @author JinXing 
	 * @date 2017年3月8日 20:37:30
	 * 
	 * 将弹题keys（每一个key对应缓存中的一条数据）存入缓存
	 * @param keys	lessonTestQuestionIds
	 * @param smallLessonId 小节id	
	 * @return void
	 * */
	public void setLessonTestQuestionRedisIds(final String keys,final Integer smallLessonId){
		
		//把keys放入Redis中
		Map<String, String> keyMap = new HashMap<String, String>();
		keyMap.put(LessonTestQuestionIdsKeys, keys);
		final Map<String, String> map = keyMap;
		// 存key到缓存
		jedisExecutor.execute( new Handler() {
			@Override
			public void handle(Jedis jedis) {
				//key缓存格式为 cc:smallLesson:50869
				jedis.hmset(RedisKeyHelper.getSmallLessonKey(smallLessonId), map);
				jedis.expire(RedisKeyHelper.getSmallLessonKey(smallLessonId), DEFAULT_EXPIRE);
			}
		});
	}
	
	/**
	 * 缓存操作
	 * @author JinXing 
	 * @date 2017年3月8日 20:37:30
	 * 
	 * 将key（每一个key对应缓存中的一条数据）存入缓存
	 * @param lessonTestQuestionid 小节id	
	 * @return LessonTestQuestion
	 * */
	public LessonTestQuestion setLessonTestQuestionData(final Integer lessonTestQuestionid){
		LessonTestQuestion LessonTestQuestion=this.searchLessonTestQuestionByid(lessonTestQuestionid);
		
		if(LessonTestQuestion ==null){
			return LessonTestQuestion;
		}
		//把对象转成map对象，自动过滤空值
		final Map<String,String> map=BeanHelper.describe(LessonTestQuestion);
		if(!CollectionUtils.isEmpty(map)){
			
			//把对象放缓存内
			jedisExecutor.execute( new Handler() {
				@Override
				public void handle(Jedis jedis) {
					jedis.hmset(RedisKeyHelper.getlessonTestQuestionKey(lessonTestQuestionid), map);
					jedis.expire(RedisKeyHelper.getlessonTestQuestionKey(lessonTestQuestionid), DEFAULT_EXPIRE);
					
				}
			});
			
		}
		return LessonTestQuestion;
	}
	
	
	/** 
	 * 为满足学堂视频弹题的展示，海外的弹题的key与cc的key存储方式。暂时调整一致 
	 * 
	* @Title: setLessonTestQuestionByRedis 
	* @Description: 根据id获取视频打点对象，根据cc打点的存储结构将获取的信息放入两个缓存中
	* @param @param lessonTestQuestionid
	* @param @return    设定文件 
	* @return LessonTestQuestion    返回类型 
	* @throws 
	*/
	public LessonTestQuestion setLessonTestQuestionByRedis(final Integer lessonTestQuestionid){
		LessonTestQuestion lessonTestQuestion=this.searchLessonTestQuestionByid(lessonTestQuestionid);
		
		final Integer lessonId=lessonTestQuestion.getLessonId();
		final Integer id=lessonTestQuestion.getLessonTestQuestionId();
		final Integer lessonVideoId= lessonTestQuestion.getSmallLessonId();//小节id
		final String timer=lessonTestQuestion.getTimer(); //打点信息
		final Integer testQuestionId=lessonTestQuestion.getTestQuestionId();//试题id
			
		if( !"".equals(timer) && testQuestionId!=null){
			
			//把对象放缓存内
			jedisExecutor.execute( new Handler() {
				@Override
				public void handle(Jedis jedis) {
					
					String timerKey=RedisKeyHelper.getLessonTestQuestionTimerKey(lessonId, lessonVideoId);//打点时间keys
					String QuestionIdsKey=RedisKeyHelper.getQuestionIds(lessonId, lessonVideoId, timer);//弹题ids key
					String idKey=RedisKeyHelper.getLessonTestionIds(lessonId, lessonVideoId, timer, testQuestionId.toString());//主键id key
					//如果存在打点时间,将打点信息追加到缓存中。不存在，直接添加
					if(jedis.exists(timerKey)){
						String timerKeyValue=jedis.get(timerKey);
						//过滤可能重复的时间点
						if(timerKeyValue.indexOf(timer) ==-1){
							System.out.println();
							if( !"".equals(timerKeyValue) && !timerKeyValue.endsWith(",")){
								timerKeyValue =timerKeyValue+",";						
							}
							jedis.set(timerKey, timerKeyValue+timer);
							jedis.expire(timerKey, DEFAULT_EXPIRE);//设置key的失效时间
						}						
						
					}else{
						jedis.set(timerKey, timer);
						jedis.expire(timerKey, DEFAULT_EXPIRE);//设置key的失效时间
					}
					
					//如果存在试题ids,将ids追加到缓存中。不存在，直接添加
					if(jedis.exists(QuestionIdsKey)){
						String idsKeyValue=jedis.get(QuestionIdsKey);
						
						//过滤可能重复的试题id
						if(idsKeyValue.indexOf(testQuestionId.toString())==-1){
							
							if( !"".equals(idsKeyValue) && !idsKeyValue.endsWith(",")){
								idsKeyValue =idsKeyValue+",";
							}
							jedis.set(QuestionIdsKey, idsKeyValue+testQuestionId.toString());
							jedis.expire(QuestionIdsKey, DEFAULT_EXPIRE);//设置key的失效时间
						}					
					}else{
						jedis.set(QuestionIdsKey, testQuestionId.toString());
						jedis.expire(QuestionIdsKey, DEFAULT_EXPIRE);//设置key的失效时间
					}
					
					//保存打点的主键id（临时方案，之后会有调整）
					jedis.set(idKey, id.toString());
					jedis.expire(idKey, DEFAULT_EXPIRE);//设置key的失效时间
				}
			});
			
		}
		return lessonTestQuestion;
	}
	
	/**
	 * 缓存操作
	 * @author JinXing 
	 * @date 2017年3月8日 20:37:30
	 * 
	 * 根据小节id获取弹题list
	 * 1.根据小节id 查询对应的缓存keys
	 * 2.根据key（每一个key对应缓存中的一条数据）,查询对应的lessonTest对象。
	 * 3.组装成list集合并返回
	 * @param smallLessonId
	 * @return List<LessonTestQuestion>
	 */
	public List<LessonTestQuestion>getLessonTestQuestionRedisDataList(final Integer smallLessonId){

		List<LessonTestQuestion> lessonTestQuestionList=new ArrayList<LessonTestQuestion>();
		
		//根据小节id获取视频弹题关联Ids
		try {
			//小节对应的keys：("lessonTestQuestionIds":"cc:lessontestquestion:15548,cc:lessontestquestion:15550")
			String ids=	this.getLessonTestQuestionRedisIds(smallLessonId);
			if(ids!=null &&  !"".equals(ids) && ids.trim().length()!=0){
				
				for (String lessonTestId :ids.split(",")) {
					
					//根据视频弹题关联Id获取视频弹题对象
					LessonTestQuestion lessonTestQuestiontemp=this.getLessonTestQuestionData(Integer.parseInt(lessonTestId));
					
					if(lessonTestQuestiontemp !=null){
						lessonTestQuestionList.add(lessonTestQuestiontemp);
					}
				}
			}
		} catch (Exception e) {
			log.error(e.toString());
		}
		return lessonTestQuestionList;
	}
	
	
	//验证数据库中的数量与缓存中的数量是否一致，不一致时重新加载一次
	Boolean dbCompareRedisSource(final Integer lessonId,final Integer smallLessonId){
		
		final Integer dbLength=this.searchLessonTestQuestionInfoLength(new LessonTestQuestion(lessonId,smallLessonId));

		if(dbLength !=null && dbLength >0){
			
			try {
				
				jedisExecutor.execute( new Handler() {
					@Override
					public void handle(Jedis jedis) {
						
						//<1>根据小节id获取打点时间timers
						String timerkey = RedisKeyHelper.getLessonTestQuestionTimerKey(lessonId,smallLessonId);
						if (jedis.exists(timerkey)) {
							
							// 如果Key存在，获取小节下所有的弹题时间  格式如下：（00:00:01,00:00:02）
							String timerKeyValue=jedis.get(timerkey);
							if(timerKeyValue !=null &&  !"".equals(timerKeyValue) && timerKeyValue.trim().length() >0){
								Integer redisLength=0;
								String[] timersArray = timerKeyValue.split(",");
								
								//<2>根据小节id、节id、timer时间点获取弹题ids
								 for (int i = 0; i < timersArray.length; i++) {

									String timer =timersArray[i];
									if(timer !=null &&  !"".equals(timer) && timer.trim().length() >0){
										
										 String questionidsKey=RedisKeyHelper.getQuestionIds(lessonId, smallLessonId, timer);									 
										 if (jedis.exists(questionidsKey)) {
											 
											// 如果Key存在，获取该时间点下所有的试题id 格式如下：（112080,112081）
											 String questionidsKeyValue=jedis.get(questionidsKey);
											 
											 if(questionidsKeyValue !=null &&  !"".equals(questionidsKeyValue) && questionidsKeyValue.trim().length() >0){
												 String[] idsArray = questionidsKeyValue.split(",");
												 for (int j = 0; j < idsArray.length; j++) {
													 //过滤空值
													 if(!"".equals(idsArray[j]) && idsArray[j].trim().length() >0){
														 redisLength++;
													 }										
												 }
												 
											 }
										 }
									}
								 }
								
								 //如果缓存中的数量与数据库的数量不一致重新加载一次
								 if(redisLength.intValue() != dbLength.intValue()){
									 setLessonTestListByRedis(lessonId,smallLessonId);
								 }
								 
							}
							
						}
						
						
					}
				});
						
			} catch (Exception e) {
				log.error(e.toString());
			}
			
			return true;
		}
		
		//数据库无数据时，缓存中还有数据，清空缓存（目前只清空timers的key）
		jedisExecutor.execute( new Handler() {
			@Override
			public void handle(Jedis jedis) {
				
				//<1>根据小节id获取打点时间timers
				String timerkey = RedisKeyHelper.getLessonTestQuestionTimerKey(lessonId,smallLessonId);
				if(jedis.exists(timerkey)){
					jedis.del(timerkey);
				}
			}
		});
		
		return false;
		
	}
	
	
	/** 
	 * 为满足学堂视频弹题的展示，海外的弹题的key与cc的key存储方式。暂时调整一致 
	 * 
	* @Title: getLessonTestListByRedis 
	* @Description: 根据小节id、节id获取打点信息（redis操作）
	* @param @param lessonId
	* @param @param smallLessonId
	* @param @return    入参
	* @return List<LessonTestQuestion>    返回类型
	* @author JinXing 
	* @throws
	* @date 2017年3月22日 下午1:19:56 
	* @version V1.0   
	*/
	List<LessonTestQuestion>getLessonTestListByRedis(final Integer lessonId,final Integer smallLessonId){
		
		final List<LessonTestQuestion> lessonTestQuestionList=new ArrayList<LessonTestQuestion>();
		try {
			
			jedisExecutor.execute( new Handler() {
				@Override
				public void handle(Jedis jedis) {
					
					//<1>根据小节id获取打点时间timers
					String timerkey = RedisKeyHelper.getLessonTestQuestionTimerKey(lessonId,smallLessonId);
					if (jedis.exists(timerkey)) {
						
						// 如果Key存在，获取小节下所有的弹题时间  格式如下：（00:00:01,00:00:02）
						String timerKeyValue=jedis.get(timerkey);
						if(timerKeyValue !=null &&  !"".equals(timerKeyValue) && timerKeyValue.trim().length() >0){

							String[] timersArray = timerKeyValue.split(",");
							 
							//<2>根据小节id、节id、timer时间点获取弹题ids
							 for (int i = 0; i < timersArray.length; i++) {

								String timer =timersArray[i];
								if(timer !=null &&  !"".equals(timer) && timer.trim().length() >0){
									
									 String questionidsKey=RedisKeyHelper.getQuestionIds(lessonId, smallLessonId, timer);									 
									 if (jedis.exists(questionidsKey)) {
										 
										// 如果Key存在，获取该时间点下所有的试题id 格式如下：（112080,112081）
										 String questionidsKeyValue=jedis.get(questionidsKey);
										 
										 if(questionidsKeyValue !=null &&  !"".equals(questionidsKeyValue) && questionidsKeyValue.trim().length() >0){
											 String[] idsArray = questionidsKeyValue.split(",");
											 
											 for (int j = 0; j < idsArray.length; j++) {
												 
												 //一个时间点可能存在多个试题id(兼容CC多个试题情况)
												 String qustionid=idsArray[j];
												 
												 //根据小节id、timer、试题id获取主键id（前端业务需求，之后会有调整）
												 String idKey=RedisKeyHelper.getLessonTestionIds(lessonId, smallLessonId, timer, qustionid);
												 String id=jedis.get(idKey);
												 if(qustionid !=null &&  !"".equals(qustionid) && qustionid.trim().length() >0){
													 LessonTestQuestion lessonTest=new LessonTestQuestion();
													 lessonTest.setLessonTestQuestionId(Integer.parseInt(id));
													 lessonTest.setTimer(timer);
													 lessonTest.setLessonId(lessonId);
													 lessonTest.setSmallLessonId(smallLessonId);
													 lessonTest.setTestQuestionId(Integer.parseInt(qustionid));
													 lessonTestQuestionList.add(lessonTest);
												 }
												 
											 }
										 }
									 }
								}
							 }
							
						}
						
					}
					
					
				}
			});
			
			return lessonTestQuestionList;			
		} catch (Exception e) {
			log.error(e.toString());
		}
		
		return null;
		
	}
	
	
	
	
	/**
	 * 缓存操作
	 * @author JinXing 
	 * @date 2017年3月8日 20:37:30
	 * 
	 * 根据小节id 查找缓存对应的keys
	 * @param smallLessonId 小节Id
	 * @return String
	 * */
	public String getLessonTestQuestionRedisIds(final Integer smallLessonId){
		final StringBuffer  lessonTestQuestionIds = new StringBuffer();
		jedisExecutor.execute( new Handler() {
			@Override
			public void handle(Jedis jedis) {
				String key = RedisKeyHelper.getSmallLessonKey(smallLessonId.longValue());
				if (jedis.exists(key)) {
					
					// 如果Key存在，将信息转换为LessonTestQuestion
					Map<String, String> map = jedis.hgetAll(key);
					
					if (!CollectionUtils.isEmpty(map) && map.get(LessonTestQuestionIdsKeys) != null) {
						lessonTestQuestionIds.append(map.get(LessonTestQuestionIdsKeys));
					}
				}
			}
		});
		return lessonTestQuestionIds != null ? lessonTestQuestionIds.toString() : null;
	}
	
	/**
	 * 缓存操作
	 * @author JinXing 
	 * @date 2017年3月8日 20:37:30
	 * 
	 * 根据弹题key（每一个key对应缓存中的一条数据） 查找缓存对应的lessonTestQuestion对象
	 * @param lessonTestQuestionid 弹题id
	 * @return LessonTestQuestion
	 * */
	public LessonTestQuestion getLessonTestQuestionData(final Integer lessonTestQuestionid){

		final LessonTestQuestion  lessonTestQuestion = new LessonTestQuestion();
		jedisExecutor.execute( new Handler() {
			@Override
			public void handle(Jedis jedis) {
				LessonTestQuestion lessonTestQuestiontemp=new LessonTestQuestion();
				//获取视频试题关联key:cc:lessontestquestion:123
				String key = RedisKeyHelper.getlessonTestQuestionKey(lessonTestQuestionid);
				
				// 如果Key存在，将信息转换为LessonTestQuestion
				if (jedis.exists(key)) {
					
					//通过key获取Redis数据
					Map<String, String> map = jedis.hgetAll(key);
					
					if (!CollectionUtils.isEmpty(map) && map.get("lessonTestQuestionId") != null) {
						lessonTestQuestiontemp=BeanHelper.transTo(map, LessonTestQuestion.class);
					}
				}
				if(lessonTestQuestiontemp !=null){
					BeanHelper.copyProperties(lessonTestQuestiontemp,lessonTestQuestion);
				}
			}
		});
		return lessonTestQuestion;		
	}
	

	
	
	/**
	 * @author JinXing 
	 * @date 2017年3月8日 20:37:30
	 * 
	 * 根据key（每一个key对应缓存中的一条数据）清除缓存
	 * @param lessonTestQuestionid
	 * @return void 
	 */
	@SuppressWarnings("unused")
	private void removeCache(final Integer lessonTestQuestionid) {
		jedisExecutor.execute( new Handler() {
			@Override
			public void handle(Jedis jedis) {
				jedis.del(RedisKeyHelper.getlessonTestQuestionKey(lessonTestQuestionid));
			}
		});
	}
	
	
	/** 
	 * 为满足学堂视频弹题的展示，海外的弹题的key与cc的key存储方式。暂时调整一致 
	 * 
	* @Title: removeCache 
	* @Description: 删除一个打点时间
	* @param @param lessonTestQuestionid    设定文件 
	* @return void    返回类型 
	* @throws 
	*/
	private void removeCacheByRedis(final LessonTestQuestion lessonTestQuestion) {
		
		final Integer lessonId= lessonTestQuestion.getLessonId();//节id
		final Integer smallLessonId =lessonTestQuestion.getSmallLessonId();//小节id
		final String timer=lessonTestQuestion.getTimer();//打点时间
		final Integer questionId=lessonTestQuestion.getTestQuestionId();//试题id
		
		if(lessonId!=null  && timer !=null && !"".equals(timer)){
			
			jedisExecutor.execute( new Handler() {
				@Override
				public void handle(Jedis jedis) {
					
					//移除时间点key,对应的缓存试题ids
					String questionIdsKey=RedisKeyHelper.getQuestionIds(lessonId, smallLessonId, timer);
					if(jedis.exists(questionIdsKey)){
						String questionIdsKeyValue=jedis.get(questionIdsKey);
						if(questionIdsKeyValue !=null &&  !"".equals(questionIdsKeyValue)){
							
							questionIdsKeyValue=questionIdsKeyValue.replace(""+questionId, "").replace(",,", ",");
							if(questionIdsKeyValue.startsWith(",")){
								questionIdsKeyValue=questionIdsKeyValue.substring(1,questionIdsKeyValue.length());
							}
							//如果试题ids内容为空时，删除key值。同时删除对应的打点时间
							if(questionIdsKeyValue =="" || questionIdsKeyValue.trim().length()==0){
								jedis.del(questionIdsKey);
								
								//删除当前的打点时间
								String timersKey=RedisKeyHelper.getLessonTestQuestionTimerKey(lessonId, smallLessonId);
								if(jedis.exists(timersKey)){
									String timersKeyValue=jedis.get(timersKey);
									if(timersKeyValue !=null &&  !"".equals(timersKeyValue)){
										
										timersKeyValue=timersKeyValue.replace(""+timer, "").replace(",,", ",");
										if(timersKeyValue.startsWith(",")){
											timersKeyValue=timersKeyValue.substring(1,timersKeyValue.length());
										}
										//如果弹题时间为空，删除key值。（目前海外的弹题时间是一对一）
										if(timersKeyValue =="" || timersKeyValue.trim().length() ==0){
											jedis.del(timersKey);
										}else{
											jedis.set(timersKey, timersKeyValue);
											jedis.expire(timersKey, DEFAULT_EXPIRE);//设置key的失效时间	
										}										
									}
								}
							}else{
								jedis.set(questionIdsKey, questionIdsKeyValue);
								jedis.expire(questionIdsKey, DEFAULT_EXPIRE);//设置key的失效时间
							}
							
							//移除主键id
							String idKey=RedisKeyHelper.getLessonTestionIds(lessonId, smallLessonId, timer, questionId.toString());
							jedis.del(idKey);
						}
					}
					
				}
			});
		}
	}
	
	
	/** 
	 * 为满足学堂视频弹题的展示，海外的弹题的key与cc的key存储方式。暂时调整一致 
	 * 
	* @Title: updateCacheByRedis 
	* @Description: T修改缓存信息，目前弹题的修改只能修改时间。修改所涉及的缓存：弹题时间缓存（直接）、试题ids缓存（间接）、主键id缓存（间接）
	* @param @param lessonTestQuestion    设定文件 
	* @return void    返回类型 
	* @throws 
	*/
	private void updateCacheByRedis(final LessonTestQuestion lessonTestQuestion) {
		
		final Integer lessonId= lessonTestQuestion.getLessonId();//节id
		final Integer smallLessonId=lessonTestQuestion.getSmallLessonId();
		final String timer=lessonTestQuestion.getTimer();
		final String newTimer=lessonTestQuestion.getNewTimer();
		jedisExecutor.execute( new Handler() {
			@Override
			public void handle(Jedis jedis) {
				String timersKey=RedisKeyHelper.getLessonTestQuestionTimerKey(lessonId, smallLessonId);//弹题时间key
				String questionIdskey=RedisKeyHelper.getQuestionIds(lessonId, smallLessonId, timer);//试题ids Key
				String newQuestionIdskey=RedisKeyHelper.getQuestionIds(lessonId, smallLessonId, newTimer);//更新的时间点的key
				if(jedis.exists(timersKey)){
					
					//获取时间点信息，更替新的时间点
					String timersKeyValue=jedis.get(timersKey);
					if(timersKeyValue !=null &&  !"".equals(timersKeyValue) && timersKeyValue.indexOf(timer)!=-1){
						//如果替换的时间已经存在，删除重复的时间
						if(timersKeyValue.indexOf(newTimer)!=-1){
							timersKeyValue=timersKeyValue.replace(timer,"");
						}else{
							timersKeyValue=timersKeyValue.replace(timer,newTimer);
						}
						
						if( !"".equals(timersKeyValue) && timersKeyValue.startsWith(","))
							timersKeyValue=timersKeyValue.substring(1, timersKeyValue.length());
						if( !"".equals(timersKeyValue) && timersKeyValue.endsWith(","))
							timersKeyValue=timersKeyValue.substring(0, timersKeyValue.length()-1);

						jedis.set(timersKey, timersKeyValue);
						jedis.expire(timersKey, DEFAULT_EXPIRE);//设置key的失效时间	
					}
					
					if(jedis.exists(questionIdskey)){
						String questionIdskeyValue=jedis.get(questionIdskey);
						if(questionIdskeyValue !=null &&  !"".equals(questionIdskeyValue)){
							
							//获取试题ids信息  删除旧key，将信息放入新key中
							jedis.del(questionIdskey);
							//更新的时间可能存在弹题
							String newQuestionIdskeyValue=jedis.get(newQuestionIdskey);
							if(newQuestionIdskeyValue !=null && !"".equals(newQuestionIdskeyValue)){
								if(!questionIdskeyValue.endsWith(","))
									questionIdskeyValue=questionIdskeyValue+",";
								questionIdskeyValue=questionIdskeyValue+newQuestionIdskeyValue;
							}
							jedis.set(newQuestionIdskey, questionIdskeyValue);
							jedis.expire(newQuestionIdskey, DEFAULT_EXPIRE);//设置key的失效时间	
							
							//获取视频打点的主键id  删除旧key,将信息放入新key中
							String questionIds[]=questionIdskeyValue.split(",");
							for (int i = 0; i < questionIds.length; i++) {
								String questionId=questionIds[i];
								String idKey=RedisKeyHelper.getLessonTestionIds(lessonId, smallLessonId, timer, questionId.toString());//主键id缓存
								if(jedis.exists(idKey)){
									String newIdKey=RedisKeyHelper.getLessonTestionIds(lessonId, smallLessonId, newTimer, questionId.toString());//新的主键id缓存
									String idKeyValue=jedis.get(idKey);
									jedis.del(idKey);
									jedis.set(newIdKey, idKeyValue);
									jedis.expire(newIdKey, DEFAULT_EXPIRE);//设置key的失效时间	
								}
								
							}

						}
											
					}
					
				}
								
			}
		});
	}
	
	/**
	 * @author JinXing 
	 * @date 2017年3月8日 20:37:30
	 * 
	 * 根据keys（每一个key对应缓存中的一条数据,keys对应多个key）清除缓存
	 * @param smallLessonId 小节id
	 * @return void 
	 */
	@SuppressWarnings("unused")
	private void removeCacheKeys(final Integer smallLessonId) {
		jedisExecutor.execute( new Handler() {
			@Override
			public void handle(Jedis jedis) {
				jedis.del(RedisKeyHelper.getSmallLessonKey(smallLessonId));
			}
		});
	}
	
	
	/**
	 * @author JinXing 
	 * @date 2017年3月8日 20:37:30
	 * 
	 * 保存弹题关联对象 ,在缓存中添加key（每一个key对应缓存中的一条数据）,同时更新keys值
	 * @param timer	小节视频打点时间
	 * @param lessonId 节id
	 * @param testQuestionId 试题id
	 * @param smallLessonId  小节id
	 * @param isDelete	是否删除  0.否1.是  默认保存0	
	 * @return LessonTestQuestion
	 * */
	public LessonTestQuestion save(LessonTestQuestion lessonTestQuestion){
		Integer lessonId=lessonTestQuestion.getLessonId();
		Integer smallLessonId=lessonTestQuestion.getSmallLessonId();
		Assert.notNull(smallLessonId,"smallLessonId must  be not null");
		Assert.notNull(lessonId,"lessonId must  be not null");
		
		//如果节下面存在小节，弹题与小节相关联 。不存在小节与节相关联。（haveChildren =0:不存在小节  HaveChildren >0 表示小节总数）
		//将SmallLessonId设为null,就是用于区分所获取的缓存key
		Integer haveChildren=this.getLessonHaveChildrenCount(smallLessonId);
		if(haveChildren!=null && haveChildren ==1){
			lessonTestQuestion.setSmallLessonId(null);
		}
		lessonTestQuestionMapper.save(lessonTestQuestion);
		
		//存缓存
		lessonTestQuestion=this.setLessonTestQuestionByRedis(lessonTestQuestion.getLessonTestQuestionId());
		
		return lessonTestQuestion;
	}
	
	/**
	 * @author JinXing 
	 * @date 2017年3月8日 20:37:30
	 * 
	 * 删除弹题关联对象，同时删除缓存的key（每一个key对应缓存中的一条数据），清空缓存中的keys
	 * @param lessonTestQuestionId 弹题关联id
	 * @return Integer
	 * */
	
	public Integer remove(Integer lessonTestQuestionId){
		Assert.notNull(lessonTestQuestionId,"lessonTestQuestionId must not be null");
		
		LessonTestQuestion lessonTestQuestion=this.searchLessonTestQuestionByid(lessonTestQuestionId);
		Integer temp=null;
		if(lessonTestQuestion !=null){
			temp=lessonTestQuestionMapper.remove(lessonTestQuestionId);

			//删除缓存
			this.removeCacheByRedis(lessonTestQuestion);
		}
		
		return temp;
	}
	
	/** 
	* @Title: removeLessonTestBySmallLessonId 
	* @Description: 根据节id、小节id删除视频打点信息
	* @param @param lessonId
	* @param @param smallLessonId
	* @param @return    设定文件 
	* @return Integer    返回类型 
	* @throws 
	*/
	private Integer removeLessonTestBySmallLessonId(LessonTestQuestion lessonTestQuestion){
		
		return lessonTestQuestionMapper.removeLessonTestBySmallLessonId(lessonTestQuestion);
	}
	
	/**
	 * @author JinXing 
	 * @date 2017年3月8日 20:37:30
	 * 
	 * 修改弹题关联对象,同时更新缓存中的key
	 * @param id 弹题关联id
	 * @param timer	小节视频打点时间
	 * @param lessonId 节id
	 * @param testQuestionId 试题id
	 * @param smallLessonId  小节id
	 * @param isDelete	是否删除  0.否1.是  默认保存0	
	 * @return LessonTestQuestion
	 * */
	public LessonTestQuestion update(LessonTestQuestion lessonTestQuestion){
		Integer id=lessonTestQuestion.getLessonTestQuestionId();
		String newTimer =lessonTestQuestion.getTimer();

		Assert.notNull(id,"lessonTestQuestionId must not be null");
		Assert.notNull(newTimer,"timer must not be null");
		
		LessonTestQuestion lessonTest=this.searchLessonTestQuestionByid(id);
		String timer=lessonTest.getTimer();
		if(timer !=null && !timer.equals(newTimer)){
			lessonTest.setNewTimer(newTimer);//更改之后的时间点
//			Integer smallLessonId=lessonTest.getSmallLessonId();
//			Integer haveChildren=this.getLessonHaveChildrenCount(smallLessonId);
//			//haveChildren==1时，节下面只有一个小节，打点信息与节关联。 haveChildren>1时，节下面有两个小节，打点信息与小节关联
//			if(haveChildren <=1){
//				lessonTest.setSmallLessonId(null);
//			}
			//为了兼容CC一个时间点存在多个弹题的清空，此方法会更新多个打点信息
			lessonTestQuestionMapper.update(lessonTest);
			
			//保证对象必要信息的完整性（缓存操作需用到），timer、id为必传项
			this.updateCacheByRedis(lessonTest);
		}
		return lessonTest;
	}
	
	
	/** 
	 * 数据库操作
	 * 
	* @Title: updateSmallLessonIdByLessonId 
	* @Description: 根据lessonId修改 SmallLessonId为空的字段
	* @param @param lessonTestQuestion
	* @param @return    设定文件 
	* @return Integer    返回类型 
	* @throws 
	*/
	private Integer updateSmallLessonIdByLessonId(LessonTestQuestion lessonTestQuestion){
		
		return lessonTestQuestionMapper.updateSmallLessonIdByLessonId(lessonTestQuestion);
	}
	
	/** 
	* @Title: getLessonHaveChildren 
	* @Description: 获取节下 小节的个数  （haveChildren=0 没有    haveChildren>0 小节的个数）
	* @param @param lessonId
	* @param @return    设定文件 
	* @return Integer    返回类型 
	* @throws 
	*/
	public Integer getLessonHaveChildren(Integer lessonId){
	
		//如果节下面存在小节，弹题与小节相关联 。不存在小节与节相关联。（haveChildren =0:不存在小节  HaveChildren >0 表示小节总数）
		//将SmallLessonId设为null,就是用于区分所获取的缓存key
		
		Assert.notNull(lessonId, "节id 应不为空");
		LessonDto lesson=lessonService.get(lessonId);
		Integer haveChildren=lesson.getHaveChildren();
		
		return haveChildren;
	}

	//根据LessonVideoId 查询其（父）节下面当前的 节视频数目
	public Integer getLessonHaveChildrenCount(Integer smallLessonId){
		LessonVideoCount count=lessonVideoAllServiceDB.countLvsAndGetLessonId(smallLessonId);	
		return count.getCount();
	}

	//增加一个小节    
	@Override
	public void updateLessonTestByAddLesson(Integer lessonId, Integer smallLessonId) {
		Assert.notNull(lessonId,"lessonId is must be not null ");
		//查询节视频下是否有打点信息    smallLessonId=null  没有小节
		if(smallLessonId !=null){
			//获取节下视频打点的数量
			Integer dbLength=this.searchLessonTestQuestionInfoLengthByLessonId(new LessonTestQuestion(lessonId));
			if(dbLength !=null && dbLength >0){
				Integer haveChildren=getLessonHaveChildrenCount(smallLessonId);
				//当节下面有两个小节的时候，需要把节下视频打点的缓存数据改为小节下视频打点的缓存数据。同时更新该节下打点信息smalllessonId为空的数据
				if(haveChildren ==Lesson_haveChildren_2.intValue()){
					//将节关联的打点信息smallLessonid=null 的字段更新为 smallLessonId值
					updateSmallLessonIdByLessonId(new LessonTestQuestion(lessonId,smallLessonId));
					
					//将节缓存变更为小节缓存
					updateLessonTestRedisByAddLesson(lessonId,smallLessonId,true);
				}
				
			}
		}
		
	}
	
	//将打点信息的节缓存改为打点信息的小节缓存
	//参数：节id、小节id
	//is_lessonToSmallLesson true:节变小节  false:小节变节
	public void updateLessonTestRedisByAddLesson(final Integer lessonId,final Integer smallLessonId,final Boolean is_lessonToSmallLesson){
		
		jedisExecutor.execute(new Handler() {
			@Override
			public void handle(Jedis jedis) {
				Integer oldSmallLessonId;//变更前的smallLessonId
				Integer newSmallLessonId;//变更后的smallLessonId
				if(is_lessonToSmallLesson){//节变小节
					oldSmallLessonId=null;
					newSmallLessonId=smallLessonId;
				}else{//小节变节
					oldSmallLessonId=smallLessonId;
					newSmallLessonId=null;
				}
				
				//小节id为空查询的是打点的节缓存   不为空查询的是打点的小节缓存
				String old_timersKey=RedisKeyHelper.getLessonTestQuestionTimerKey(lessonId, oldSmallLessonId);//节时间点key
				if(jedis.exists(old_timersKey)){
					String old_timersKeyValue=jedis.get(old_timersKey);
					if(old_timersKeyValue!=null && !"".equals(old_timersKeyValue)){
						//获取打点节缓存对应的打点时间数据，删除节打点时间缓存替换为小节打点时间缓存
						jedis.del(old_timersKey);
						String new_timersKey=RedisKeyHelper.getLessonTestQuestionTimerKey(lessonId, newSmallLessonId);//小节时间点key
						jedis.set(new_timersKey, old_timersKeyValue);
						jedis.expire(new_timersKey, DEFAULT_EXPIRE);//设置key的失效时间
						
						//节时间点缓存存在多个时间点，每个时间点对应多个试题ids
						String[] timersArray = old_timersKeyValue.split(",");
						for (int i = 0; i < timersArray.length; i++) {
							String timer=timersArray[i];
							if(timer!=null && !"".equals(timer)){
								
								//根据时间点获取节试题ids key,删除节试题ids key替换为小节试题ids key
								String old_questionIdsKey=RedisKeyHelper.getQuestionIds(lessonId, oldSmallLessonId, timer);//节试题ids key
								if(old_questionIdsKey !=null && !"".equals(old_questionIdsKey)){
									String old_questionIdsKeyValue=jedis.get(old_questionIdsKey);
									if(old_questionIdsKeyValue!=null && !"".equals(old_questionIdsKeyValue) ){
										jedis.del(old_questionIdsKey);
										String new_questionIdsKey=RedisKeyHelper.getQuestionIds(lessonId, newSmallLessonId, timer);//小节试题ids key
										jedis.set(new_questionIdsKey, old_questionIdsKeyValue);
										jedis.expire(new_questionIdsKey, DEFAULT_EXPIRE);//设置key的失效时间
										
										//试题ids对应多个试题id,每个试题id对应一个打点信息的主键id（由于treenity的业务需求，临时加的）
										String[] questionArray = old_questionIdsKeyValue.split(",");
										for (int j = 0; j < questionArray.length; j++) {
											String questionId=questionArray[j];
											if(questionId!=null && !"".equals(questionId)){
												String old_idKey=RedisKeyHelper.getLessonTestionIds(lessonId, oldSmallLessonId, timer, questionId);//节 打点主键id
												String old_idKeyValue=jedis.get(old_idKey);
												String new_idkey=RedisKeyHelper.getLessonTestionIds(lessonId, newSmallLessonId, timer, questionId);//小节节 打点主键id
												jedis.del(old_idKey);
												jedis.set(new_idkey, old_idKeyValue);
												jedis.expire(new_idkey, DEFAULT_EXPIRE);//设置key的失效时间
											}
										}
									}
								}
								
							}
						}
						
					}
				}
			}
		});
		
	}

	//删除一个小节
	@Override
	public void updateLessonTestByDelLesson(Integer lessonId, Integer delSmallLessonId) {
		Assert.notNull(lessonId,"lessonId is must be not null ");
		//查询节视频下是否有打点信息    smallLessonId=null  没有小节
		if(delSmallLessonId !=null){
			
			//节下面只有一个小节时,需要把小节下视频打点的缓存数据改为节下视频打点的缓存数据。同时将该小节下打点信息smalllessonId置为空
			Integer haveChildren=this.getLessonHaveChildrenCount(delSmallLessonId);
			if(haveChildren >= Lesson_haveChildren_2.intValue()){
				//删除小节下关联的打点信息
				this.removeLessonTestBySmallLessonId(new LessonTestQuestion(lessonId,delSmallLessonId));
				this.removeSmallLessonTestByRedis(lessonId,delSmallLessonId);
			}else if(haveChildren == Lesson_haveChildren_1.intValue()){
				//删除小节下关联的打点信息
				this.removeLessonTestBySmallLessonId(new LessonTestQuestion(lessonId,delSmallLessonId));
				this.updateSmallLessonIdByLessonId(new LessonTestQuestion(lessonId,null));
				LessonVideo lessonVideo=lessonVideoAllServiceDB.selectFirstVideoInfo(lessonId);
				//获取节下第一个小节id
				if(lessonVideo !=null){				
					Integer updateSmallLessonId= lessonVideo.getId();
					this.updateLessonTestRedisByAddLesson(lessonId, updateSmallLessonId, false);
				}
				
			}else if(haveChildren == Lesson_haveChildren_0.intValue()){
				//删除小节下关联的打点信息
				this.removeLessonTestBySmallLessonId(new LessonTestQuestion(lessonId,null));
				this.removeSmallLessonTestByRedis(lessonId,null);
			}
			
		}
		
	}
	
	//删除小节下的信息
	private void removeSmallLessonTestByRedis(final Integer lessonId,final Integer smallLessonId){
		jedisExecutor.execute( new Handler() {
			@Override
			public void handle(Jedis jedis) {
				String timersKeys=RedisKeyHelper.getLessonTestQuestionTimerKey(lessonId, smallLessonId);
				jedis.del(timersKeys);
			}
		});
	}
	
}
